home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / src / api2.c < prev    next >
C/C++ Source or Header  |  1999-02-04  |  32KB  |  1,422 lines
  1. /* $Id: api2.c,v 3.6 1998/08/21 02:43:52 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.0
  6.  * Copyright (C) 1995-1998  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: api2.c,v $
  26.  * Revision 3.6  1998/08/21 02:43:52  brianp
  27.  * implemented true packing/unpacking of polygon stipples
  28.  *
  29.  * Revision 3.5  1998/07/26 02:32:43  brianp
  30.  * removed unused variable
  31.  *
  32.  * Revision 3.4  1998/03/27 03:30:36  brianp
  33.  * fixed G++ warnings
  34.  *
  35.  * Revision 3.3  1998/03/10 01:26:57  brianp
  36.  * updated for David's v0.23 fxmesa driver
  37.  *
  38.  * Revision 3.2  1998/02/20 04:49:19  brianp
  39.  * move extension functions into apiext.c
  40.  *
  41.  * Revision 3.1  1998/02/06 01:57:42  brianp
  42.  * added GL 1.2 3-D texture enums and functions
  43.  *
  44.  * Revision 3.0  1998/01/31 20:43:12  brianp
  45.  * initial rev
  46.  *
  47.  */
  48.  
  49.  
  50. #ifdef PC_HEADER
  51. #include "all.h"
  52. #else
  53. #include <stdio.h>
  54. #include <stdlib.h>
  55. #include "api.h"
  56. #include "context.h"
  57. #include "image.h"
  58. #include "macros.h"
  59. #include "matrix.h"
  60. #include "teximage.h"
  61. #include "types.h"
  62. #include "vb.h"
  63. #endif
  64.  
  65.  
  66. /*
  67.  * Part 2 of API functions
  68.  */
  69.  
  70.  
  71. void APIENTRY glOrtho( GLdouble left, GLdouble right,
  72.                        GLdouble bottom, GLdouble top,
  73.                        GLdouble nearval, GLdouble farval )
  74. {
  75.    GET_CONTEXT;
  76.    CHECK_CONTEXT;
  77.    (*CC->API.Ortho)(CC, left, right, bottom, top, nearval, farval);
  78. }
  79.  
  80.  
  81. void APIENTRY glPassThrough( GLfloat token )
  82. {
  83.    GET_CONTEXT;
  84.    CHECK_CONTEXT;
  85.    (*CC->API.PassThrough)(CC, token);
  86. }
  87.  
  88.  
  89. void APIENTRY glPixelMapfv( GLenum map, GLint mapsize, const GLfloat *values )
  90. {
  91.    GET_CONTEXT;
  92.    CHECK_CONTEXT;
  93.    (*CC->API.PixelMapfv)( CC, map, mapsize, values );
  94. }
  95.  
  96.  
  97. void APIENTRY glPixelMapuiv( GLenum map, GLint mapsize, const GLuint *values )
  98. {
  99.    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
  100.    GLint i;
  101.    GET_CONTEXT;
  102.    CHECK_CONTEXT;
  103.  
  104.    if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
  105.       for (i=0;i<mapsize;i++) {
  106.          fvalues[i] = (GLfloat) values[i];
  107.       }
  108.    }
  109.    else {
  110.       for (i=0;i<mapsize;i++) {
  111.          fvalues[i] = UINT_TO_FLOAT( values[i] );
  112.       }
  113.    }
  114.    (*CC->API.PixelMapfv)( CC, map, mapsize, fvalues );
  115. }
  116.  
  117.  
  118.  
  119. void APIENTRY glPixelMapusv( GLenum map, GLint mapsize, const GLushort *values )
  120. {
  121.    GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
  122.    GLint i;
  123.    GET_CONTEXT;
  124.    CHECK_CONTEXT;
  125.  
  126.    if (map==GL_PIXEL_MAP_I_TO_I || map==GL_PIXEL_MAP_S_TO_S) {
  127.       for (i=0;i<mapsize;i++) {
  128.          fvalues[i] = (GLfloat) values[i];
  129.       }
  130.    }
  131.    else {
  132.       for (i=0;i<mapsize;i++) {
  133.          fvalues[i] = USHORT_TO_FLOAT( values[i] );
  134.       }
  135.    }
  136.    (*CC->API.PixelMapfv)( CC, map, mapsize, fvalues );
  137. }
  138.  
  139.  
  140. void APIENTRY glPixelStoref( GLenum pname, GLfloat param )
  141. {
  142.    GET_CONTEXT;
  143.    CHECK_CONTEXT;
  144.    (*CC->API.PixelStorei)( CC, pname, (GLint) param );
  145. }
  146.  
  147.  
  148. void APIENTRY glPixelStorei( GLenum pname, GLint param )
  149. {
  150.    GET_CONTEXT;
  151.    CHECK_CONTEXT;
  152.    (*CC->API.PixelStorei)( CC, pname, param );
  153. }
  154.  
  155.  
  156. void APIENTRY glPixelTransferf( GLenum pname, GLfloat param )
  157. {
  158.    GET_CONTEXT;
  159.    CHECK_CONTEXT;
  160.    (*CC->API.PixelTransferf)(CC, pname, param);
  161. }
  162.  
  163.  
  164. void APIENTRY glPixelTransferi( GLenum pname, GLint param )
  165. {
  166.    GET_CONTEXT;
  167.    CHECK_CONTEXT;
  168.    (*CC->API.PixelTransferf)(CC, pname, (GLfloat) param);
  169. }
  170.  
  171.  
  172. void APIENTRY glPixelZoom( GLfloat xfactor, GLfloat yfactor )
  173. {
  174.    GET_CONTEXT;
  175.    CHECK_CONTEXT;
  176.    (*CC->API.PixelZoom)(CC, xfactor, yfactor);
  177. }
  178.  
  179.  
  180. void APIENTRY glPointSize( GLfloat size )
  181. {
  182.    GET_CONTEXT;
  183.    CHECK_CONTEXT;
  184.    (*CC->API.PointSize)(CC, size);
  185. }
  186.  
  187.  
  188. void APIENTRY glPolygonMode( GLenum face, GLenum mode )
  189. {
  190.    GET_CONTEXT;
  191.    CHECK_CONTEXT;
  192.    (*CC->API.PolygonMode)(CC, face, mode);
  193. }
  194.  
  195.  
  196. void APIENTRY glPolygonOffset( GLfloat factor, GLfloat units )
  197. {
  198.    GET_CONTEXT;
  199.    CHECK_CONTEXT;
  200.    (*CC->API.PolygonOffset)( CC, factor, units );
  201. }
  202.  
  203.  
  204. /* GL_EXT_polygon_offset */
  205. void APIENTRY glPolygonOffsetEXT( GLfloat factor, GLfloat bias )
  206. {
  207.    glPolygonOffset( factor, bias * DEPTH_SCALE );
  208. }
  209.  
  210.  
  211. void APIENTRY glPolygonStipple( const GLubyte *pattern )
  212. {
  213.    GLuint unpackedPattern[32];
  214.    GET_CONTEXT;
  215.    CHECK_CONTEXT;
  216.    gl_unpack_polygon_stipple( CC, pattern, unpackedPattern );
  217.    (*CC->API.PolygonStipple)(CC, unpackedPattern);
  218. }
  219.  
  220.  
  221. void APIENTRY glPopAttrib( void )
  222. {
  223.    GET_CONTEXT;
  224.    CHECK_CONTEXT;
  225.    (*CC->API.PopAttrib)(CC);
  226. }
  227.  
  228.  
  229. void APIENTRY glPopClientAttrib( void )
  230. {
  231.    GET_CONTEXT;
  232.    CHECK_CONTEXT;
  233.    (*CC->API.PopClientAttrib)(CC);
  234. }
  235.  
  236.  
  237. void APIENTRY glPopMatrix( void )
  238. {
  239.    GET_CONTEXT;
  240.    CHECK_CONTEXT;
  241.    (*CC->API.PopMatrix)( CC );
  242. }
  243.  
  244.  
  245. void APIENTRY glPopName( void )
  246. {
  247.    GET_CONTEXT;
  248.    CHECK_CONTEXT;
  249.    (*CC->API.PopName)(CC);
  250. }
  251.  
  252.  
  253. void APIENTRY glPrioritizeTextures( GLsizei n, const GLuint *textures,
  254.                                     const GLclampf *priorities )
  255. {
  256.    GET_CONTEXT;
  257.    CHECK_CONTEXT;
  258.    (*CC->API.PrioritizeTextures)(CC, n, textures, priorities);
  259. }
  260.  
  261.  
  262. void APIENTRY glPushMatrix( void )
  263. {
  264.    GET_CONTEXT;
  265.    CHECK_CONTEXT;
  266.    (*CC->API.PushMatrix)( CC );
  267. }
  268.  
  269.  
  270. void APIENTRY glRasterPos2d( GLdouble x, GLdouble y )
  271. {
  272.    GET_CONTEXT;
  273.    CHECK_CONTEXT;
  274.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  275. }
  276.  
  277.  
  278. void APIENTRY glRasterPos2f( GLfloat x, GLfloat y )
  279. {
  280.    GET_CONTEXT;
  281.    CHECK_CONTEXT;
  282.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  283. }
  284.  
  285.  
  286. void APIENTRY glRasterPos2i( GLint x, GLint y )
  287. {
  288.    GET_CONTEXT;
  289.    CHECK_CONTEXT;
  290.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  291. }
  292.  
  293.  
  294. void APIENTRY glRasterPos2s( GLshort x, GLshort y )
  295. {
  296.    GET_CONTEXT;
  297.    CHECK_CONTEXT;
  298.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, 0.0F, 1.0F );
  299. }
  300.  
  301.  
  302. void APIENTRY glRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
  303. {
  304.    GET_CONTEXT;
  305.    CHECK_CONTEXT;
  306.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  307. }
  308.  
  309.  
  310. void APIENTRY glRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
  311. {
  312.    GET_CONTEXT;
  313.    CHECK_CONTEXT;
  314.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  315. }
  316.  
  317.  
  318. void APIENTRY glRasterPos3i( GLint x, GLint y, GLint z )
  319. {
  320.    GET_CONTEXT;
  321.    CHECK_CONTEXT;
  322.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  323. }
  324.  
  325.  
  326. void APIENTRY glRasterPos3s( GLshort x, GLshort y, GLshort z )
  327. {
  328.    GET_CONTEXT;
  329.    CHECK_CONTEXT;
  330.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F );
  331. }
  332.  
  333.  
  334. void APIENTRY glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
  335. {
  336.    GET_CONTEXT;
  337.    CHECK_CONTEXT;
  338.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y,
  339.                                (GLfloat) z, (GLfloat) w );
  340. }
  341.  
  342.  
  343. void APIENTRY glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  344. {
  345.    GET_CONTEXT;
  346.    CHECK_CONTEXT;
  347.    (*CC->API.RasterPos4f)( CC, x, y, z, w );
  348. }
  349.  
  350.  
  351. void APIENTRY glRasterPos4i( GLint x, GLint y, GLint z, GLint w )
  352. {
  353.    GET_CONTEXT;
  354.    CHECK_CONTEXT;
  355.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y,
  356.                            (GLfloat) z, (GLfloat) w );
  357. }
  358.  
  359.  
  360. void APIENTRY glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
  361. {
  362.    GET_CONTEXT;
  363.    CHECK_CONTEXT;
  364.    (*CC->API.RasterPos4f)( CC, (GLfloat) x, (GLfloat) y,
  365.                            (GLfloat) z, (GLfloat) w );
  366. }
  367.  
  368.  
  369. void APIENTRY glRasterPos2dv( const GLdouble *v )
  370. {
  371.    GET_CONTEXT;
  372.    CHECK_CONTEXT;
  373.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  374. }
  375.  
  376.  
  377. void APIENTRY glRasterPos2fv( const GLfloat *v )
  378. {
  379.    GET_CONTEXT;
  380.    CHECK_CONTEXT;
  381.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  382. }
  383.  
  384.  
  385. void APIENTRY glRasterPos2iv( const GLint *v )
  386. {
  387.    GET_CONTEXT;
  388.    CHECK_CONTEXT;
  389.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  390. }
  391.  
  392.  
  393. void APIENTRY glRasterPos2sv( const GLshort *v )
  394. {
  395.    GET_CONTEXT;
  396.    CHECK_CONTEXT;
  397.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F );
  398. }
  399.  
  400.  
  401. /*** 3 element vector ***/
  402.  
  403. void APIENTRY glRasterPos3dv( const GLdouble *v )
  404. {
  405.    GET_CONTEXT;
  406.    CHECK_CONTEXT;
  407.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  408.                            (GLfloat) v[2], 1.0F );
  409. }
  410.  
  411.  
  412. void APIENTRY glRasterPos3fv( const GLfloat *v )
  413. {
  414.    GET_CONTEXT;
  415.    CHECK_CONTEXT;
  416.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  417.                                (GLfloat) v[2], 1.0F );
  418. }
  419.  
  420.  
  421. void APIENTRY glRasterPos3iv( const GLint *v )
  422. {
  423.    GET_CONTEXT;
  424.    CHECK_CONTEXT;
  425.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  426.                            (GLfloat) v[2], 1.0F );
  427. }
  428.  
  429.  
  430. void APIENTRY glRasterPos3sv( const GLshort *v )
  431. {
  432.    GET_CONTEXT;
  433.    CHECK_CONTEXT;
  434.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  435.                            (GLfloat) v[2], 1.0F );
  436. }
  437.  
  438.  
  439. void APIENTRY glRasterPos4dv( const GLdouble *v )
  440. {
  441.    GET_CONTEXT;
  442.    CHECK_CONTEXT;
  443.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  444.                            (GLfloat) v[2], (GLfloat) v[3] );
  445. }
  446.  
  447.  
  448. void APIENTRY glRasterPos4fv( const GLfloat *v )
  449. {
  450.    GET_CONTEXT;
  451.    CHECK_CONTEXT;
  452.    (*CC->API.RasterPos4f)( CC, v[0], v[1], v[2], v[3] );
  453. }
  454.  
  455.  
  456. void APIENTRY glRasterPos4iv( const GLint *v )
  457. {
  458.    GET_CONTEXT;
  459.    CHECK_CONTEXT;
  460.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  461.                            (GLfloat) v[2], (GLfloat) v[3] );
  462. }
  463.  
  464.  
  465. void APIENTRY glRasterPos4sv( const GLshort *v )
  466. {
  467.    GET_CONTEXT;
  468.    CHECK_CONTEXT;
  469.    (*CC->API.RasterPos4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  470.                            (GLfloat) v[2], (GLfloat) v[3] );
  471. }
  472.  
  473.  
  474. void APIENTRY glReadBuffer( GLenum mode )
  475. {
  476.    GET_CONTEXT;
  477.    CHECK_CONTEXT;
  478.    (*CC->API.ReadBuffer)( CC, mode );
  479. }
  480.  
  481.  
  482. void APIENTRY glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height,
  483.            GLenum format, GLenum type, GLvoid *pixels )
  484. {
  485.    GET_CONTEXT;
  486.    CHECK_CONTEXT;
  487.    (*CC->API.ReadPixels)( CC, x, y, width, height, format, type, pixels );
  488. }
  489.  
  490.  
  491. void APIENTRY glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
  492. {
  493.    GET_CONTEXT;
  494.    CHECK_CONTEXT;
  495.    (*CC->API.Rectf)( CC, (GLfloat) x1, (GLfloat) y1,
  496.                      (GLfloat) x2, (GLfloat) y2 );
  497. }
  498.  
  499.  
  500. void APIENTRY glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
  501. {
  502.    GET_CONTEXT;
  503.    CHECK_CONTEXT;
  504.    (*CC->API.Rectf)( CC, x1, y1, x2, y2 );
  505. }
  506.  
  507.  
  508. void APIENTRY glRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
  509. {
  510.    GET_CONTEXT;
  511.    CHECK_CONTEXT;
  512.    (*CC->API.Rectf)( CC, (GLfloat) x1, (GLfloat) y1,
  513.                          (GLfloat) x2, (GLfloat) y2 );
  514. }
  515.  
  516.  
  517. void APIENTRY glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
  518. {
  519.    GET_CONTEXT;
  520.    CHECK_CONTEXT;
  521.    (*CC->API.Rectf)( CC, (GLfloat) x1, (GLfloat) y1,
  522.                      (GLfloat) x2, (GLfloat) y2 );
  523. }
  524.  
  525.  
  526. void APIENTRY glRectdv( const GLdouble *v1, const GLdouble *v2 )
  527. {
  528.    GET_CONTEXT;
  529.    CHECK_CONTEXT;
  530.    (*CC->API.Rectf)(CC, (GLfloat) v1[0], (GLfloat) v1[1],
  531.                     (GLfloat) v2[0], (GLfloat) v2[1]);
  532. }
  533.  
  534.  
  535. void APIENTRY glRectfv( const GLfloat *v1, const GLfloat *v2 )
  536. {
  537.    GET_CONTEXT;
  538.    CHECK_CONTEXT;
  539.    (*CC->API.Rectf)(CC, v1[0], v1[1], v2[0], v2[1]);
  540. }
  541.  
  542.  
  543. void APIENTRY glRectiv( const GLint *v1, const GLint *v2 )
  544. {
  545.    GET_CONTEXT;
  546.    CHECK_CONTEXT;
  547.    (*CC->API.Rectf)( CC, (GLfloat) v1[0], (GLfloat) v1[1],
  548.                      (GLfloat) v2[0], (GLfloat) v2[1] );
  549. }
  550.  
  551.  
  552. void APIENTRY glRectsv( const GLshort *v1, const GLshort *v2 )
  553. {
  554.    GET_CONTEXT;
  555.    CHECK_CONTEXT;
  556.    (*CC->API.Rectf)(CC, (GLfloat) v1[0], (GLfloat) v1[1],
  557.         (GLfloat) v2[0], (GLfloat) v2[1]);
  558. }
  559.  
  560.  
  561. void APIENTRY glScissor( GLint x, GLint y, GLsizei width, GLsizei height)
  562. {
  563.    GET_CONTEXT;
  564.    CHECK_CONTEXT;
  565.    (*CC->API.Scissor)(CC, x, y, width, height);
  566. }
  567.  
  568.  
  569. GLboolean APIENTRY glIsEnabled( GLenum cap )
  570. {
  571.    GET_CONTEXT;
  572.    CHECK_CONTEXT_RETURN(GL_FALSE);
  573.    return (*CC->API.IsEnabled)( CC, cap );
  574. }
  575.  
  576.  
  577.  
  578. void APIENTRY glPushAttrib( GLbitfield mask )
  579. {
  580.    GET_CONTEXT;
  581.    CHECK_CONTEXT;
  582.    (*CC->API.PushAttrib)(CC, mask);
  583. }
  584.  
  585.  
  586. void APIENTRY glPushClientAttrib( GLbitfield mask )
  587. {
  588.    GET_CONTEXT;
  589.    CHECK_CONTEXT;
  590.    (*CC->API.PushClientAttrib)(CC, mask);
  591. }
  592.  
  593.  
  594. void APIENTRY glPushName( GLuint name )
  595. {
  596.    GET_CONTEXT;
  597.    CHECK_CONTEXT;
  598.    (*CC->API.PushName)(CC, name);
  599. }
  600.  
  601.  
  602. GLint APIENTRY glRenderMode( GLenum mode )
  603. {
  604.    GET_CONTEXT;
  605.    CHECK_CONTEXT_RETURN(0);
  606.    return (*CC->API.RenderMode)(CC, mode);
  607. }
  608.  
  609.  
  610. void APIENTRY glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
  611. {
  612.    GET_CONTEXT;
  613.    CHECK_CONTEXT;
  614.    (*CC->API.Rotatef)( CC, (GLfloat) angle,
  615.                        (GLfloat) x, (GLfloat) y, (GLfloat) z );
  616. }
  617.  
  618.  
  619. void APIENTRY glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
  620. {
  621.    GET_CONTEXT;
  622.    CHECK_CONTEXT;
  623.    (*CC->API.Rotatef)( CC, angle, x, y, z );
  624. }
  625.  
  626.  
  627. void APIENTRY glSelectBuffer( GLsizei size, GLuint *buffer )
  628. {
  629.    GET_CONTEXT;
  630.    CHECK_CONTEXT;
  631.    (*CC->API.SelectBuffer)(CC, size, buffer);
  632. }
  633.  
  634.  
  635. void APIENTRY glScaled( GLdouble x, GLdouble y, GLdouble z )
  636. {
  637.    GET_CONTEXT;
  638.    CHECK_CONTEXT;
  639.    (*CC->API.Scalef)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
  640. }
  641.  
  642.  
  643. void APIENTRY glScalef( GLfloat x, GLfloat y, GLfloat z )
  644. {
  645.    GET_CONTEXT;
  646.    CHECK_CONTEXT;
  647.    (*CC->API.Scalef)( CC, x, y, z );
  648. }
  649.  
  650.  
  651. void APIENTRY glShadeModel( GLenum mode )
  652. {
  653.    GET_CONTEXT;
  654.    CHECK_CONTEXT;
  655.    (*CC->API.ShadeModel)(CC, mode);
  656. }
  657.  
  658.  
  659. void APIENTRY glStencilFunc( GLenum func, GLint ref, GLuint mask )
  660. {
  661.    GET_CONTEXT;
  662.    CHECK_CONTEXT;
  663.    (*CC->API.StencilFunc)(CC, func, ref, mask);
  664. }
  665.  
  666.  
  667. void APIENTRY glStencilMask( GLuint mask )
  668. {
  669.    GET_CONTEXT;
  670.    CHECK_CONTEXT;
  671.    (*CC->API.StencilMask)(CC, mask);
  672. }
  673.  
  674.  
  675. void APIENTRY glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
  676. {
  677.    GET_CONTEXT;
  678.    CHECK_CONTEXT;
  679.    (*CC->API.StencilOp)(CC, fail, zfail, zpass);
  680. }
  681.  
  682.  
  683. void APIENTRY glTexCoord1d( GLdouble s )
  684. {
  685.    GET_CONTEXT;
  686.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, 0.0, 0.0, 1.0 );
  687. }
  688.  
  689.  
  690. void APIENTRY glTexCoord1f( GLfloat s )
  691. {
  692.    GET_CONTEXT;
  693.    (*CC->API.TexCoord4f)( CC, s, 0.0, 0.0, 1.0 );
  694. }
  695.  
  696.  
  697. void APIENTRY glTexCoord1i( GLint s )
  698. {
  699.    GET_CONTEXT;
  700.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, 0.0, 0.0, 1.0 );
  701. }
  702.  
  703.  
  704. void APIENTRY glTexCoord1s( GLshort s )
  705. {
  706.    GET_CONTEXT;
  707.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, 0.0, 0.0, 1.0 );
  708. }
  709.  
  710.  
  711. void APIENTRY glTexCoord2d( GLdouble s, GLdouble t )
  712. {
  713.    GET_CONTEXT;
  714.    (*CC->API.TexCoord2f)( CC, (GLfloat) s, (GLfloat) t );
  715. }
  716.  
  717.  
  718. void APIENTRY glTexCoord2f( GLfloat s, GLfloat t )
  719. {
  720.    GET_CONTEXT;
  721.    (*CC->API.TexCoord2f)( CC, s, t );
  722. }
  723.  
  724.  
  725. void APIENTRY glTexCoord2i( GLint s, GLint t )
  726. {
  727.    GET_CONTEXT;
  728.    (*CC->API.TexCoord2f)( CC, (GLfloat) s, (GLfloat) t );
  729. }
  730.  
  731.  
  732. void APIENTRY glTexCoord2s( GLshort s, GLshort t )
  733. {
  734.    GET_CONTEXT;
  735.    (*CC->API.TexCoord2f)( CC, (GLfloat) s, (GLfloat) t );
  736. }
  737.  
  738.  
  739. void APIENTRY glTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
  740. {
  741.    GET_CONTEXT;
  742.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t, (GLfloat) r, 1.0 );
  743. }
  744.  
  745.  
  746. void APIENTRY glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
  747. {
  748.    GET_CONTEXT;
  749.    (*CC->API.TexCoord4f)( CC, s, t, r, 1.0 );
  750. }
  751.  
  752.  
  753. void APIENTRY glTexCoord3i( GLint s, GLint t, GLint r )
  754. {
  755.    GET_CONTEXT;
  756.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
  757.                                (GLfloat) r, 1.0 );
  758. }
  759.  
  760.  
  761. void APIENTRY glTexCoord3s( GLshort s, GLshort t, GLshort r )
  762. {
  763.    GET_CONTEXT;
  764.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
  765.                                (GLfloat) r, 1.0 );
  766. }
  767.  
  768.  
  769. void APIENTRY glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
  770. {
  771.    GET_CONTEXT;
  772.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
  773.                                (GLfloat) r, (GLfloat) q );
  774. }
  775.  
  776.  
  777. void APIENTRY glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
  778. {
  779.    GET_CONTEXT;
  780.    (*CC->API.TexCoord4f)( CC, s, t, r, q );
  781. }
  782.  
  783.  
  784. void APIENTRY glTexCoord4i( GLint s, GLint t, GLint r, GLint q )
  785. {
  786.    GET_CONTEXT;
  787.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
  788.                                (GLfloat) r, (GLfloat) q );
  789. }
  790.  
  791.  
  792. void APIENTRY glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
  793. {
  794.    GET_CONTEXT;
  795.    (*CC->API.TexCoord4f)( CC, (GLfloat) s, (GLfloat) t,
  796.                                (GLfloat) r, (GLfloat) q );
  797. }
  798.  
  799.  
  800. void APIENTRY glTexCoord1dv( const GLdouble *v )
  801. {
  802.    GET_CONTEXT;
  803.    (*CC->API.TexCoord4f)( CC, (GLfloat) *v, 0.0, 0.0, 1.0 );
  804. }
  805.  
  806.  
  807. void APIENTRY glTexCoord1fv( const GLfloat *v )
  808. {
  809.    GET_CONTEXT;
  810.    (*CC->API.TexCoord4f)( CC, *v, 0.0, 0.0, 1.0 );
  811. }
  812.  
  813.  
  814. void APIENTRY glTexCoord1iv( const GLint *v )
  815. {
  816.    GET_CONTEXT;
  817.    (*CC->API.TexCoord4f)( CC, *v, 0.0, 0.0, 1.0 );
  818. }
  819.  
  820.  
  821. void APIENTRY glTexCoord1sv( const GLshort *v )
  822. {
  823.    GET_CONTEXT;
  824.    (*CC->API.TexCoord4f)( CC, (GLfloat) *v, 0.0, 0.0, 1.0 );
  825. }
  826.  
  827.  
  828. void APIENTRY glTexCoord2dv( const GLdouble *v )
  829. {
  830.    GET_CONTEXT;
  831.    (*CC->API.TexCoord2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
  832. }
  833.  
  834.  
  835. void APIENTRY glTexCoord2fv( const GLfloat *v )
  836. {
  837.    GET_CONTEXT;
  838.    (*CC->API.TexCoord2f)( CC, v[0], v[1] );
  839. }
  840.  
  841.  
  842. void APIENTRY glTexCoord2iv( const GLint *v )
  843. {
  844.    GET_CONTEXT;
  845.    (*CC->API.TexCoord2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
  846. }
  847.  
  848.  
  849. void APIENTRY glTexCoord2sv( const GLshort *v )
  850. {
  851.    GET_CONTEXT;
  852.    (*CC->API.TexCoord2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
  853. }
  854.  
  855.  
  856. void APIENTRY glTexCoord3dv( const GLdouble *v )
  857. {
  858.    GET_CONTEXT;
  859.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  860.                                (GLfloat) v[2], 1.0 );
  861. }
  862.  
  863.  
  864. void APIENTRY glTexCoord3fv( const GLfloat *v )
  865. {
  866.    GET_CONTEXT;
  867.    (*CC->API.TexCoord4f)( CC, v[0], v[1], v[2], 1.0 );
  868. }
  869.  
  870.  
  871. void APIENTRY glTexCoord3iv( const GLint *v )
  872. {
  873.    GET_CONTEXT;
  874.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  875.                           (GLfloat) v[2], 1.0 );
  876. }
  877.  
  878.  
  879. void APIENTRY glTexCoord3sv( const GLshort *v )
  880. {
  881.    GET_CONTEXT;
  882.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  883.                                (GLfloat) v[2], 1.0 );
  884. }
  885.  
  886.  
  887. void APIENTRY glTexCoord4dv( const GLdouble *v )
  888. {
  889.    GET_CONTEXT;
  890.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  891.                                (GLfloat) v[2], (GLfloat) v[3] );
  892. }
  893.  
  894.  
  895. void APIENTRY glTexCoord4fv( const GLfloat *v )
  896. {
  897.    GET_CONTEXT;
  898.    (*CC->API.TexCoord4f)( CC, v[0], v[1], v[2], v[3] );
  899. }
  900.  
  901.  
  902. void APIENTRY glTexCoord4iv( const GLint *v )
  903. {
  904.    GET_CONTEXT;
  905.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  906.                                (GLfloat) v[2], (GLfloat) v[3] );
  907. }
  908.  
  909.  
  910. void APIENTRY glTexCoord4sv( const GLshort *v )
  911. {
  912.    GET_CONTEXT;
  913.    (*CC->API.TexCoord4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  914.                                (GLfloat) v[2], (GLfloat) v[3] );
  915. }
  916.  
  917.  
  918. void APIENTRY glTexCoordPointer( GLint size, GLenum type, GLsizei stride,
  919.                                  const GLvoid *ptr )
  920. {
  921.    GET_CONTEXT;
  922.    CHECK_CONTEXT;
  923.    (*CC->API.TexCoordPointer)(CC, size, type, stride, ptr);
  924. }
  925.  
  926.  
  927. void APIENTRY glTexGend( GLenum coord, GLenum pname, GLdouble param )
  928. {
  929.    GLfloat p = (GLfloat) param;
  930.    GET_CONTEXT;
  931.    CHECK_CONTEXT;
  932.    (*CC->API.TexGenfv)( CC, coord, pname, &p );
  933. }
  934.  
  935.  
  936. void APIENTRY glTexGenf( GLenum coord, GLenum pname, GLfloat param )
  937. {
  938.    GET_CONTEXT;
  939.    CHECK_CONTEXT;
  940.    (*CC->API.TexGenfv)( CC, coord, pname, ¶m );
  941. }
  942.  
  943.  
  944. void APIENTRY glTexGeni( GLenum coord, GLenum pname, GLint param )
  945. {
  946.    GLfloat p = (GLfloat) param;
  947.    GET_CONTEXT;
  948.    CHECK_CONTEXT;
  949.    (*CC->API.TexGenfv)( CC, coord, pname, &p );
  950. }
  951.  
  952.  
  953. void APIENTRY glTexGendv( GLenum coord, GLenum pname, const GLdouble *params )
  954. {
  955.    GLfloat p[4];
  956.    GET_CONTEXT;
  957.    CHECK_CONTEXT;
  958.    p[0] = params[0];
  959.    p[1] = params[1];
  960.    p[2] = params[2];
  961.    p[3] = params[3];
  962.    (*CC->API.TexGenfv)( CC, coord, pname, p );
  963. }
  964.  
  965.  
  966. void APIENTRY glTexGeniv( GLenum coord, GLenum pname, const GLint *params )
  967. {
  968.    GLfloat p[4];
  969.    GET_CONTEXT;
  970.    CHECK_CONTEXT;
  971.    p[0] = params[0];
  972.    p[1] = params[1];
  973.    p[2] = params[2];
  974.    p[3] = params[3];
  975.    (*CC->API.TexGenfv)( CC, coord, pname, p );
  976. }
  977.  
  978.  
  979. void APIENTRY glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
  980. {
  981.    GET_CONTEXT;
  982.    CHECK_CONTEXT;
  983.    (*CC->API.TexGenfv)( CC, coord, pname, params );
  984. }
  985.  
  986.  
  987.  
  988.  
  989. void APIENTRY glTexEnvf( GLenum target, GLenum pname, GLfloat param )
  990. {
  991.    GET_CONTEXT;
  992.    CHECK_CONTEXT;
  993.    (*CC->API.TexEnvfv)( CC, target, pname, ¶m );
  994. }
  995.  
  996.  
  997.  
  998. void APIENTRY glTexEnvi( GLenum target, GLenum pname, GLint param )
  999. {
  1000.    GLfloat p[4];
  1001.    GET_CONTEXT;
  1002.    p[0] = (GLfloat) param;
  1003.    p[1] = p[2] = p[3] = 0.0;
  1004.    CHECK_CONTEXT;
  1005.    (*CC->API.TexEnvfv)( CC, target, pname, p );
  1006. }
  1007.  
  1008.  
  1009.  
  1010. void APIENTRY glTexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
  1011. {
  1012.    GET_CONTEXT;
  1013.    CHECK_CONTEXT;
  1014.    (*CC->API.TexEnvfv)( CC, target, pname, param );
  1015. }
  1016.  
  1017.  
  1018.  
  1019. void APIENTRY glTexEnviv( GLenum target, GLenum pname, const GLint *param )
  1020. {
  1021.    GLfloat p[4];
  1022.    GET_CONTEXT;
  1023.    p[0] = INT_TO_FLOAT( param[0] );
  1024.    p[1] = INT_TO_FLOAT( param[1] );
  1025.    p[2] = INT_TO_FLOAT( param[2] );
  1026.    p[3] = INT_TO_FLOAT( param[3] );
  1027.    CHECK_CONTEXT;
  1028.    (*CC->API.TexEnvfv)( CC, target, pname, p );
  1029. }
  1030.  
  1031.  
  1032. void APIENTRY glTexImage1D( GLenum target, GLint level, GLint internalformat,
  1033.                             GLsizei width, GLint border,
  1034.                             GLenum format, GLenum type, const GLvoid *pixels )
  1035. {
  1036.    struct gl_image *teximage;
  1037.    GET_CONTEXT;
  1038.    CHECK_CONTEXT;
  1039.    teximage = gl_unpack_image( CC, width, 1, format, type, pixels );
  1040.    (*CC->API.TexImage1D)( CC, target, level, internalformat,
  1041.                           width, border, format, type, teximage );
  1042. }
  1043.  
  1044.  
  1045.  
  1046. void APIENTRY glTexImage2D( GLenum target, GLint level, GLint internalformat,
  1047.                             GLsizei width, GLsizei height, GLint border,
  1048.                             GLenum format, GLenum type, const GLvoid *pixels )
  1049. {
  1050.   struct gl_image *teximage;
  1051. #if defined(FX) && defined(__WIN32__)
  1052.   GLvoid *newpixels=NULL;
  1053.   GLsizei newwidth,newheight;
  1054.   GLint x,y;
  1055.   static GLint leveldif=0;
  1056.   static GLuint lasttexobj=0;
  1057. #endif
  1058.   GET_CONTEXT;
  1059.   CHECK_CONTEXT;
  1060.  
  1061. #if defined(FX) && defined(__WIN32__)
  1062.   newpixels=NULL;
  1063.   
  1064.   /* AN HACK for WinGLQuake*/
  1065.   
  1066.   if (CC->Texture.Set[0].Current2D->Name!=lasttexobj) {
  1067.     lasttexobj=CC->Texture.Set[0].Current2D->Name;
  1068.     leveldif=0;
  1069.   }
  1070.   
  1071.   if ((format==GL_COLOR_INDEX) && (internalformat==1))
  1072.     internalformat=GL_COLOR_INDEX8_EXT;
  1073.   
  1074.   if (width>256 || height>256) {
  1075.     newpixels=malloc((width+4)*height*4);
  1076.  
  1077.     while (width>256 || height>256) {
  1078.       newwidth=width/2;
  1079.       newheight=height/2;
  1080.       leveldif++;
  1081.       
  1082.       fprintf(stderr,"Scaling: (%d) %dx%d -> %dx%d\n",internalformat,width,height,newwidth,newheight);
  1083.       fflush(stderr);
  1084.       
  1085.       for(y=0;y<newheight;y++)
  1086.     for(x=0;x<newwidth;x++) {
  1087.       ((GLubyte *)newpixels)[(x+y*newwidth)*4+0]=((GLubyte *)pixels)[(x*2+y*width*2)*4+0];
  1088.       ((GLubyte *)newpixels)[(x+y*newwidth)*4+1]=((GLubyte *)pixels)[(x*2+y*width*2)*4+1];
  1089.       ((GLubyte *)newpixels)[(x+y*newwidth)*4+2]=((GLubyte *)pixels)[(x*2+y*width*2)*4+2];
  1090.       ((GLubyte *)newpixels)[(x+y*newwidth)*4+3]=((GLubyte *)pixels)[(x*2+y*width*2)*4+3];
  1091.     }
  1092.  
  1093.       pixels=newpixels;
  1094.       width=newwidth;
  1095.       height=newheight;
  1096.     }
  1097.     
  1098.     level=0;
  1099.   } else
  1100.     level-=leveldif;
  1101. #endif
  1102.   teximage = gl_unpack_image( CC, width, height, format, type, pixels );
  1103.   (*CC->API.TexImage2D)( CC, target, level, internalformat,
  1104.              width, height, border, format, type, teximage );
  1105. #if defined(FX) && defined(__WIN32__)
  1106.   if(newpixels)
  1107.     free(newpixels);
  1108. #endif
  1109. }
  1110.  
  1111.  
  1112. void APIENTRY glTexImage3D( GLenum target, GLint level, GLenum internalformat,
  1113.                             GLsizei width, GLsizei height, GLsizei depth,
  1114.                             GLint border, GLenum format, GLenum type,
  1115.                             const GLvoid *pixels )
  1116. {
  1117.    struct gl_image *teximage;
  1118.    GET_CONTEXT;
  1119.    CHECK_CONTEXT;
  1120.    teximage = gl_unpack_image3D( CC, width, height, depth, format, type, pixels);
  1121.    (*CC->API.TexImage3DEXT)( CC, target, level, internalformat,
  1122.                              width, height, depth, border, format, type, 
  1123.                              teximage );
  1124. }
  1125.  
  1126.  
  1127. void APIENTRY glTexParameterf( GLenum target, GLenum pname, GLfloat param )
  1128. {
  1129.    GET_CONTEXT;
  1130.    CHECK_CONTEXT;
  1131.    (*CC->API.TexParameterfv)( CC, target, pname, ¶m );
  1132. }
  1133.  
  1134.  
  1135. void APIENTRY glTexParameteri( GLenum target, GLenum pname, GLint param )
  1136. {
  1137.    GLfloat fparam[4];
  1138.    GET_CONTEXT;
  1139.    fparam[0] = (GLfloat) param;
  1140.    fparam[1] = fparam[2] = fparam[3] = 0.0;
  1141.    CHECK_CONTEXT;
  1142.    (*CC->API.TexParameterfv)( CC, target, pname, fparam );
  1143. }
  1144.  
  1145.  
  1146. void APIENTRY glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
  1147. {
  1148.    GET_CONTEXT;
  1149.    CHECK_CONTEXT;
  1150.    (*CC->API.TexParameterfv)( CC, target, pname, params );
  1151. }
  1152.  
  1153.  
  1154. void APIENTRY glTexParameteriv( GLenum target, GLenum pname, const GLint *params )
  1155. {
  1156.    GLfloat p[4];
  1157.    GET_CONTEXT;
  1158.    CHECK_CONTEXT;
  1159.    if (pname==GL_TEXTURE_BORDER_COLOR) {
  1160.       p[0] = INT_TO_FLOAT( params[0] );
  1161.       p[1] = INT_TO_FLOAT( params[1] );
  1162.       p[2] = INT_TO_FLOAT( params[2] );
  1163.       p[3] = INT_TO_FLOAT( params[3] );
  1164.    }
  1165.    else {
  1166.       p[0] = (GLfloat) params[0];
  1167.       p[1] = (GLfloat) params[1];
  1168.       p[2] = (GLfloat) params[2];
  1169.       p[3] = (GLfloat) params[3];
  1170.    }
  1171.    (*CC->API.TexParameterfv)( CC, target, pname, p );
  1172. }
  1173.  
  1174.  
  1175. void APIENTRY glTexSubImage1D( GLenum target, GLint level, GLint xoffset,
  1176.                                GLsizei width, GLenum format,
  1177.                                GLenum type, const GLvoid *pixels )
  1178. {
  1179.    struct gl_image *image;
  1180.    GET_CONTEXT;
  1181.    CHECK_CONTEXT;
  1182.    image = gl_unpack_texsubimage( CC, width, 1, format, type, pixels );
  1183.    (*CC->API.TexSubImage1D)( CC, target, level, xoffset, width,
  1184.                              format, type, image );
  1185. }
  1186.  
  1187.  
  1188. void APIENTRY glTexSubImage2D( GLenum target, GLint level,
  1189.                                GLint xoffset, GLint yoffset,
  1190.                                GLsizei width, GLsizei height,
  1191.                                GLenum format, GLenum type,
  1192.                                const GLvoid *pixels )
  1193. {
  1194.    struct gl_image *image;
  1195.    GET_CONTEXT;
  1196.    CHECK_CONTEXT;
  1197.    image = gl_unpack_texsubimage( CC, width, height, format, type, pixels );
  1198.    (*CC->API.TexSubImage2D)( CC, target, level, xoffset, yoffset,
  1199.                              width, height, format, type, image );
  1200. }
  1201.  
  1202.  
  1203. void APIENTRY glTexSubImage3D( GLenum target, GLint level, GLint xoffset,
  1204.                                GLint yoffset, GLint zoffset, GLsizei width,
  1205.                                GLsizei height, GLsizei depth, GLenum format,
  1206.                                GLenum type, const GLvoid *pixels )
  1207. {
  1208.    struct gl_image *image;
  1209.    GET_CONTEXT;
  1210.    CHECK_CONTEXT;
  1211.    image = gl_unpack_texsubimage3D( CC, width, height, depth, format, type,
  1212.                                     pixels );
  1213.    (*CC->API.TexSubImage3DEXT)( CC, target, level, xoffset, yoffset, zoffset,
  1214.                                 width, height, depth, format, type, image );
  1215. }
  1216.  
  1217.  
  1218. void APIENTRY glTranslated( GLdouble x, GLdouble y, GLdouble z )
  1219. {
  1220.    GET_CONTEXT;
  1221.    CHECK_CONTEXT;
  1222.    (*CC->API.Translatef)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
  1223. }
  1224.  
  1225.  
  1226. void APIENTRY glTranslatef( GLfloat x, GLfloat y, GLfloat z )
  1227. {
  1228.    GET_CONTEXT;
  1229.    CHECK_CONTEXT;
  1230.    (*CC->API.Translatef)( CC, x, y, z );
  1231. }
  1232.  
  1233.  
  1234. void APIENTRY glVertex2d( GLdouble x, GLdouble y )
  1235. {
  1236.    GET_CONTEXT;
  1237.    (*CC->API.Vertex2f)( CC, (GLfloat) x, (GLfloat) y );
  1238. }
  1239.  
  1240.  
  1241. void APIENTRY glVertex2f( GLfloat x, GLfloat y )
  1242. {
  1243.    GET_CONTEXT;
  1244.    (*CC->API.Vertex2f)( CC, x, y );
  1245. }
  1246.  
  1247.  
  1248. void APIENTRY glVertex2i( GLint x, GLint y )
  1249. {
  1250.    GET_CONTEXT;
  1251.    (*CC->API.Vertex2f)( CC, (GLfloat) x, (GLfloat) y );
  1252. }
  1253.  
  1254.  
  1255. void APIENTRY glVertex2s( GLshort x, GLshort y )
  1256. {
  1257.    GET_CONTEXT;
  1258.    (*CC->API.Vertex2f)( CC, (GLfloat) x, (GLfloat) y );
  1259. }
  1260.  
  1261.  
  1262. void APIENTRY glVertex3d( GLdouble x, GLdouble y, GLdouble z )
  1263. {
  1264.    GET_CONTEXT;
  1265.    (*CC->API.Vertex3f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
  1266. }
  1267.  
  1268.  
  1269. void APIENTRY glVertex3f( GLfloat x, GLfloat y, GLfloat z )
  1270. {
  1271.    GET_CONTEXT;
  1272.    (*CC->API.Vertex3f)( CC, x, y, z );
  1273. }
  1274.  
  1275.  
  1276. void APIENTRY glVertex3i( GLint x, GLint y, GLint z )
  1277. {
  1278.    GET_CONTEXT;
  1279.    (*CC->API.Vertex3f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
  1280. }
  1281.  
  1282.  
  1283. void APIENTRY glVertex3s( GLshort x, GLshort y, GLshort z )
  1284. {
  1285.    GET_CONTEXT;
  1286.    (*CC->API.Vertex3f)( CC, (GLfloat) x, (GLfloat) y, (GLfloat) z );
  1287. }
  1288.  
  1289.  
  1290. void APIENTRY glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
  1291. {
  1292.    GET_CONTEXT;
  1293.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y,
  1294.                             (GLfloat) z, (GLfloat) w );
  1295. }
  1296.  
  1297.  
  1298. void APIENTRY glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  1299. {
  1300.    GET_CONTEXT;
  1301.    (*CC->API.Vertex4f)( CC, x, y, z, w );
  1302. }
  1303.  
  1304.  
  1305. void APIENTRY glVertex4i( GLint x, GLint y, GLint z, GLint w )
  1306. {
  1307.    GET_CONTEXT;
  1308.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y,
  1309.                             (GLfloat) z, (GLfloat) w );
  1310. }
  1311.  
  1312.  
  1313. void APIENTRY glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
  1314. {
  1315.    GET_CONTEXT;
  1316.    (*CC->API.Vertex4f)( CC, (GLfloat) x, (GLfloat) y,
  1317.                             (GLfloat) z, (GLfloat) w );
  1318. }
  1319.  
  1320.  
  1321. void APIENTRY glVertex2dv( const GLdouble *v )
  1322. {
  1323.    GET_CONTEXT;
  1324.    (*CC->API.Vertex2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
  1325. }
  1326.  
  1327.  
  1328. void APIENTRY glVertex2fv( const GLfloat *v )
  1329. {
  1330.    GET_CONTEXT;
  1331.    (*CC->API.Vertex2f)( CC, v[0], v[1] );
  1332. }
  1333.  
  1334.  
  1335. void APIENTRY glVertex2iv( const GLint *v )
  1336. {
  1337.    GET_CONTEXT;
  1338.    (*CC->API.Vertex2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
  1339. }
  1340.  
  1341.  
  1342. void APIENTRY glVertex2sv( const GLshort *v )
  1343. {
  1344.    GET_CONTEXT;
  1345.    (*CC->API.Vertex2f)( CC, (GLfloat) v[0], (GLfloat) v[1] );
  1346. }
  1347.  
  1348.  
  1349. void APIENTRY glVertex3dv( const GLdouble *v )
  1350. {
  1351.    GET_CONTEXT;
  1352.    (*CC->API.Vertex3f)( CC, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
  1353. }
  1354.  
  1355.  
  1356. void APIENTRY glVertex3fv( const GLfloat *v )
  1357. {
  1358.    GET_CONTEXT;
  1359.    (*CC->API.Vertex3fv)( CC, v );
  1360. }
  1361.  
  1362.  
  1363. void APIENTRY glVertex3iv( const GLint *v )
  1364. {
  1365.    GET_CONTEXT;
  1366.    (*CC->API.Vertex3f)( CC, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
  1367. }
  1368.  
  1369.  
  1370. void APIENTRY glVertex3sv( const GLshort *v )
  1371. {
  1372.    GET_CONTEXT;
  1373.    (*CC->API.Vertex3f)( CC, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2] );
  1374. }
  1375.  
  1376.  
  1377. void APIENTRY glVertex4dv( const GLdouble *v )
  1378. {
  1379.    GET_CONTEXT;
  1380.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  1381.                             (GLfloat) v[2], (GLfloat) v[3] );
  1382. }
  1383.  
  1384.  
  1385. void APIENTRY glVertex4fv( const GLfloat *v )
  1386. {
  1387.    GET_CONTEXT;
  1388.    (*CC->API.Vertex4f)( CC, v[0], v[1], v[2], v[3] );
  1389. }
  1390.  
  1391.  
  1392. void APIENTRY glVertex4iv( const GLint *v )
  1393. {
  1394.    GET_CONTEXT;
  1395.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  1396.                             (GLfloat) v[2], (GLfloat) v[3] );
  1397. }
  1398.  
  1399.  
  1400. void APIENTRY glVertex4sv( const GLshort *v )
  1401. {
  1402.    GET_CONTEXT;
  1403.    (*CC->API.Vertex4f)( CC, (GLfloat) v[0], (GLfloat) v[1],
  1404.                             (GLfloat) v[2], (GLfloat) v[3] );
  1405. }
  1406.  
  1407.  
  1408. void APIENTRY glVertexPointer( GLint size, GLenum type, GLsizei stride,
  1409.                                const GLvoid *ptr )
  1410. {
  1411.    GET_CONTEXT;
  1412.    (*CC->API.VertexPointer)(CC, size, type, stride, ptr);
  1413. }
  1414.  
  1415.  
  1416. void APIENTRY glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
  1417. {
  1418.    GET_CONTEXT;
  1419.    (*CC->API.Viewport)( CC, x, y, width, height );
  1420. }
  1421.  
  1422.